home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 1996 September & October / Amiga-CD 1996 #9-10.iso / demos / storm-c / stormwizard / source / c-source / manager / manager.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-06  |  17.3 KB  |  611 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4.  
  5. #include    <clib/alib_protos.h>
  6. #include    <pragma/dos_lib.h>
  7. #include    <pragma/exec_lib.h>
  8. #include    <pragma/intuition_lib.h>
  9. #include    <pragma/utility_lib.h>
  10. #include    <pragma/wizard_lib.h>
  11.  
  12. #include    <exec/exec.h>
  13. #include    <exec/memory.h>
  14. #include    <intuition/gadgetclass.h>
  15. #include    <intuition/intuition.h>
  16. #include    <utility/utility.h>
  17. #include    <libraries/wizard.h>
  18.  
  19. struct Library *UtilityBase;
  20. struct Library *WizardBase;
  21.  
  22. APTR    MySurface;
  23. struct Screen *MyScreen;
  24.  
  25. struct Gadget *MyGadgets[88];
  26. struct WizardWindowHandle *MyWinHandle;
  27. struct Window *MyWindow;
  28.  
  29. struct MyWinExtension
  30. {
  31. };
  32. /* Diese Struktur wird für dann beim SF_AllocWindowHandle angelegt        **
  33. ** und im Feld UserData eingetragen !  Wenn die Größe allerdings            **
  34. ** NULL ist, dann darf dieser Zeiger nicht benutzt werden     !!!                **
  35. ** Sie könnten zum Beispiel eine Node-Struktur einbauen und damit     **
  36. ** ihre Fensterhandles verketten.                                                                            */
  37.  
  38. #define DIRTYPE        0
  39. #define FILETYPE    1
  40.  
  41. #define LToggleID    3
  42. #define RToggleID 16
  43. #define LViewID        5
  44. #define RViewID        18
  45. #define    LStringID    14
  46. #define RStringID 27
  47. #define ParentID    43
  48. #define StatusID    85
  49. #define AnzeigeID 86
  50.  
  51. struct MyListNode
  52. {
  53.     struct WizardListNode Node;
  54.     char String[256];
  55.  
  56.     int Type;
  57.     unsigned long FileSize;
  58.     char FileName[256];
  59. };
  60. /* Diese Liste beinhaltet alle wichtigen Daten für einen Eintrag und    **
  61. ** besitzt gleichzeitig die WizardListNode, die von den ListView`s         **
  62. ** bzw. in unserem Fall den MultiListViews verlangt wird.                            */
  63.  
  64. struct MinList DummyList;
  65. struct MinList LeftList;
  66. struct MinList RightList;
  67.  
  68. struct MinList *QuellList=&LeftList;
  69. struct MinList *ZielList=&RightList;
  70.  
  71. struct Gadget *QuellGadget;
  72. struct Gadget *ZielGadget;
  73.  
  74. struct Gadget *QuellStringGadget;
  75. struct Gadget *ZielStringGadget;
  76.  
  77. struct Gadget    *QuellToggleGadget;
  78. struct Gadget *ZielToggleGadget;
  79.  
  80. unsigned long QuellAnzeigeWert,ZielAnzeigeWert;
  81.  
  82. char QString[256];
  83. char ZString[256];
  84.  
  85. char *QuellAnzeige=QString;
  86. char *ZielAnzeige=ZString;
  87.  
  88. struct FileInfoBlock fib;
  89.  
  90.  
  91. void ReadDirectoryList(STRPTR device,BOOL newKopf)
  92. {
  93.     BPTR mylock;
  94.     struct ClockData MyCD;
  95.  
  96.     WZ_LockWindow(MyWinHandle);
  97.  
  98.     if (mylock=Lock(device,SHARED_LOCK))
  99.     {
  100.         if (Examine(mylock,&fib))
  101.         {
  102.             QuellAnzeigeWert=0;
  103.  
  104.             if (newKopf)
  105.                 sprintf(QuellAnzeige,"%s: ( %ldk )",&fib.fib_FileName,fib.fib_Size>>10);
  106.  
  107.             SetGadgetAttrs(QuellGadget,MyWindow,0L,WLISTVIEWA_List,&DummyList,
  108.                                                     TAG_DONE);
  109.  
  110.  
  111.             while (QuellList->mlh_Head->mln_Succ)
  112.             {
  113.                 struct MinNode *t=QuellList->mlh_Head;
  114.  
  115.                 Remove((struct Node *)t);
  116.                 FreeVec(t);
  117.             }; /* die alte geschichte löschen */
  118.  
  119.  
  120.             while (ExNext(mylock,&fib))
  121.             {
  122.                 struct MyListNode *NewNode;
  123.  
  124.                 if (NewNode=AllocVec(sizeof(MyListNode),MEMF_CLEAR|MEMF_PUBLIC))
  125.                 {
  126.                     BOOL    Ready=FALSE;
  127.  
  128.                     struct MyListNode *PredNode=(struct MyListNode *)QuellList->mlh_Head;
  129.  
  130.                     NewNode->Node.Entrys=1;
  131.  
  132.                     NewNode->Node.StringEntrys[0].Style=FS_NORMAL;
  133.                     NewNode->Node.StringEntrys[0].SStyle=FS_NORMAL;
  134.  
  135.                     NewNode->Node.VImage=0L;
  136.                     NewNode->Node.VImageTags=0L;
  137.  
  138.                     NewNode->Node.StringEntrys[0].String=NewNode->String;
  139.  
  140.                     strcpy(NewNode->FileName,fib.fib_FileName);
  141.                     Amiga2Date(fib.fib_Date.ds_Days*24*3600+fib.fib_Date.ds_Minute*60+fib.fib_Date.ds_Tick/50,&MyCD);
  142.  
  143.                     if (fib.fib_DirEntryType>=0)
  144.                     {
  145.                         NewNode->Node.StringEntrys[0].Pen=WZRD_SHINEPEN;
  146.                         NewNode->Node.StringEntrys[0].SPen=WZRD_SHINEPEN;
  147.  
  148.                         NewNode->FileSize=0;
  149.                         NewNode->Type=DIRTYPE;
  150.  
  151.                         sprintf(NewNode->String,"%-36s  %02ld.%02ld.%02ld  %02ld:%02ld:%02ld  %s",NewNode->FileName,MyCD.mday,MyCD.month,MyCD.year,MyCD.hour,MyCD.min,MyCD.sec,fib.fib_Comment);
  152.                     }
  153.                     else
  154.                     {
  155.                         NewNode->Node.StringEntrys[0].Pen=WZRD_TEXTPEN;
  156.                         NewNode->Node.StringEntrys[0].SPen=WZRD_FILLTEXTPEN;
  157.  
  158.                         NewNode->FileSize=fib.fib_Size;
  159.                         NewNode->Type=FILETYPE;
  160.  
  161.                         sprintf(NewNode->String,"%-28s %7ld  %02ld.%02ld.%02ld  %02ld:%02ld:%02ld  %s",NewNode->FileName,NewNode->FileSize,MyCD.mday,MyCD.month,MyCD.year,MyCD.hour,MyCD.min,MyCD.sec,fib.fib_Comment);
  162.                     };
  163.  
  164.                     while (!Ready && PredNode->Node.Node.mln_Succ)
  165.                     {
  166.                         if (NewNode->Type>=PredNode->Type)
  167.                         {
  168.                             if (NewNode->Type==PredNode->Type)
  169.                             {
  170.                                 if (Stricmp(NewNode->FileName,PredNode->FileName)<0)
  171.                                 {
  172.                                     PredNode=(struct MyListNode *)PredNode->Node.Node.mln_Pred    ;
  173.                                     Ready=TRUE;
  174.                                 }
  175.                                 else
  176.                                     PredNode=(struct MyListNode *)PredNode->Node.Node.mln_Succ;
  177.                             }
  178.                             else
  179.                                 PredNode=(struct MyListNode *)PredNode->Node.Node.mln_Succ;
  180.                         }
  181.                         else
  182.                         {
  183.                             PredNode=(struct MyListNode *)PredNode->Node.Node.mln_Pred;
  184.                             Ready=TRUE;
  185.                         }
  186.                     };
  187.  
  188.                     Insert((struct List *)QuellList,(struct Node *)NewNode,(struct Node *)PredNode);
  189.  
  190.                 }
  191.             };
  192.  
  193.             SetGadgetAttrs(QuellGadget,MyWindow,0L,WLISTVIEWA_List,QuellList,
  194.                                                                                         WLISTVIEWA_Top,0,
  195.                                                                                 TAG_DONE);
  196.         }
  197.  
  198.         if (newKopf)
  199.             SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Label,QuellAnzeige,
  200.                                                                             TAG_DONE);
  201.  
  202.         SetGadgetAttrs(QuellStringGadget,MyWindow,0L,WSTRINGA_String,device,
  203.                                                                             TAG_DONE);
  204.  
  205.         SetGadgetAttrs(MyGadgets[86],MyWindow,0L,WARGSA_Arg0,0,TAG_DONE);
  206.  
  207.         UnLock(mylock);
  208.     }
  209.     WZ_UnlockWindow(MyWinHandle);
  210. }
  211.  
  212.  
  213. void GoToDir(STRPTR addpath)
  214. {
  215.     char *Dir;
  216.     char NewDir[256];
  217.  
  218.     if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  219.     {
  220.         strcpy(NewDir,Dir);
  221.         AddPart(NewDir,addpath,256);
  222.  
  223.         ReadDirectoryList(NewDir,FALSE);
  224.     }
  225.  
  226. }
  227.  
  228. main()
  229. {
  230.     struct NewWindow *MyNewWindow;
  231.  
  232.     struct IntuiMessage *msg;
  233.  
  234.     ULONG MsgClass;
  235.     UWORD MsgGadgetID;
  236.  
  237.     APTR    GadgetHelpIAddress;
  238.     struct WizardWindowHandle *GadgetHelpWinHandle;
  239.  
  240.     ULONG FreeChip;
  241.     ULONG FreeFast;
  242.  
  243.     struct DateStamp MyDateStamp;
  244.     struct ClockData MyClockData;
  245.  
  246.     int a=FULLMENUNUM(0,2,0);
  247.  
  248.     NewList((struct List *)&DummyList);
  249.     NewList((struct List *)&LeftList);
  250.     NewList((struct List *)&RightList);
  251.  
  252.     if (UtilityBase=OpenLibrary("utility.library",0L))
  253.     {
  254.         if (WizardBase=OpenLibrary("wizard.library",0L))
  255.         {
  256.             if (MyScreen=LockPubScreen(0L))
  257.             {
  258.                 if (MySurface=WZ_OpenSurface("manager.wizard",0L,TAG_DONE))
  259.                 {
  260.                         if (MyWinHandle=WZ_AllocWindowHandle(MyScreen,
  261.                                                                                                 sizeof(MyWinExtension),
  262.                                                                                                 MySurface,TAG_DONE))
  263.                         {
  264.                             if (MyNewWindow=WZ_CreateWindowObj(MyWinHandle,1L,WWH_GadgetArray,MyGadgets,
  265.                                                                                                                                 WWH_GadgetArraySize,sizeof(MyGadgets),
  266.                                                                                                                                 TAG_DONE))
  267.                             {
  268.                                 FreeChip=AvailMem(MEMF_CHIP)>>10;
  269.                                 FreeFast=AvailMem(MEMF_FAST)>>10;
  270.  
  271.                                 DateStamp(&MyDateStamp);
  272.                                 Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+MyDateStamp.ds_Tick/50,&MyClockData);
  273.  
  274.                                 SetGadgetAttrs(MyGadgets[StatusID],0L,0L,WARGSA_Arg0,FreeChip,
  275.                                                                             WARGSA_Arg1,FreeFast,
  276.                                                                             WARGSA_Arg2,FreeChip+FreeFast,
  277.                                                                             WARGSA_Arg3,MyClockData.mday,
  278.                                                                             WARGSA_Arg4,MyClockData.month,
  279.                                                                             WARGSA_Arg5,MyClockData.year,
  280.                                                                             WARGSA_Arg6,MyClockData.hour,
  281.                                                                             WARGSA_Arg7,MyClockData.min,
  282.                                                                             WARGSA_Arg8,MyClockData.sec,
  283.                                                                             TAG_DONE);
  284.                                 SetGadgetAttrs(MyGadgets[LViewID],0L,0L,WLISTVIEWA_List,&LeftList,
  285.                                                                                         TAG_DONE);
  286.                                 SetGadgetAttrs(MyGadgets[RViewID],0L,0L,WLISTVIEWA_List,&RightList,
  287.                                                                                         TAG_DONE);
  288.  
  289.                                 QuellGadget=MyGadgets[LViewID];
  290.                                 ZielGadget=MyGadgets[RViewID];
  291.  
  292.                                 QuellStringGadget=MyGadgets[LStringID];
  293.                                 ZielStringGadget=MyGadgets[RStringID];
  294.  
  295.                                 QuellToggleGadget=MyGadgets[LToggleID];
  296.                                 ZielToggleGadget=MyGadgets[RToggleID];
  297.  
  298.                                 MyNewWindow->LeftEdge=0;
  299.                                 MyNewWindow->TopEdge=MyScreen->BarHeight;
  300.                                 MyNewWindow->Width=MyScreen->Width;
  301.                                 MyNewWindow->Height=MyScreen->Height-MyScreen->BarHeight;
  302.  
  303.                                 if (MyWindow=WZ_OpenWindow(MyWinHandle,MyNewWindow,WA_AutoAdjust ,TRUE,
  304.                                                                                                                                     WA_MenuHelp,TRUE,
  305.                                                                                                                                     TAG_DONE))
  306.                                 {
  307.                                     MyWindow->UserData=(BYTE *)MyWinHandle;
  308.                                     /* Wir wollen es uns schliesslich einfach machen oder ? */
  309.  
  310.                                     HelpControl(MyWindow,HC_GADGETHELP);
  311.  
  312.                                     do
  313.                                     {
  314.                                         WaitPort(MyWindow->UserPort); /* Auf CloseWindow warten*/
  315.  
  316.                                         if (msg=(struct IntuiMessage *)GetMsg(MyWindow->UserPort))
  317.                                         {
  318.                                             MsgClass=msg->Class;
  319.  
  320.                                             switch (MsgClass)
  321.                                             {
  322.                                                 case IDCMP_IDCMPUPDATE:
  323.                                                     switch (MsgGadgetID=GetTagData(GA_ID,0,(struct TagItem *)msg->IAddress))
  324.                                                     {
  325.                                                         unsigned long TWert;
  326.                                                         struct MyListNode *SelNode;
  327.  
  328.                                                         case 30:        /* die ganzen Laufwerksknöpfe */
  329.                                                         case 31:
  330.                                                         case 32:
  331.                                                         case 33:
  332.                                                         case 34:
  333.                                                         case 35:
  334.                                                         case 36:
  335.                                                         case 37:
  336.                                                         case 38:
  337.                                                         case 39:
  338.                                                         case 40:
  339.                                                             ReadDirectoryList(WZ_GadgetConfig(MyWinHandle,MyGadgets[MsgGadgetID]),TRUE);
  340.                                                             break;
  341.  
  342.                                                         case LToggleID:              /* linkes Toggle */
  343.                                                             TWert=ZielAnzeigeWert;
  344.                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  345.                                                             QuellAnzeigeWert=TWert;
  346.  
  347.                                                             QuellList=&LeftList;
  348.                                                             ZielList=&RightList;
  349.  
  350.                                                             QuellGadget=MyGadgets[LViewID];
  351.                                                             ZielGadget=MyGadgets[RViewID];
  352.  
  353.                                                             QuellStringGadget=MyGadgets[LStringID];
  354.                                                             ZielStringGadget=MyGadgets[RStringID];
  355.  
  356.                                                             QuellToggleGadget=MyGadgets[LToggleID];
  357.                                                             ZielToggleGadget=MyGadgets[RToggleID];
  358.  
  359.                                                             QuellAnzeige=QString;
  360.                                                             ZielAnzeige=ZString;
  361.  
  362.                                                             SetGadgetAttrs(MyGadgets[86],MyWindow,0L,
  363.                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  364.                                                             break;
  365.  
  366.                                                         case RToggleID:                        /* rechtes Toogle */
  367.                                                             TWert=ZielAnzeigeWert;
  368.                                                             ZielAnzeigeWert=QuellAnzeigeWert;
  369.                                                             QuellAnzeigeWert=TWert;
  370.  
  371.                                                             ZielList=&LeftList;
  372.                                                             QuellList=&RightList;
  373.  
  374.                                                             ZielGadget=MyGadgets[LViewID];
  375.                                                             QuellGadget=MyGadgets[RViewID];
  376.  
  377.                                                             ZielStringGadget=MyGadgets[LStringID];
  378.                                                             QuellStringGadget=MyGadgets[RStringID];
  379.  
  380.                                                             ZielToggleGadget=MyGadgets[LToggleID];
  381.                                                             QuellToggleGadget=MyGadgets[RToggleID];
  382.  
  383.                                                             ZielAnzeige=QString;
  384.                                                             QuellAnzeige=ZString;
  385.  
  386.                                                             SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  387.                                                                 WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  388.                                                             break;
  389.  
  390.                                                         case LViewID:                                        /* linkes MultiView */
  391.                                                             if (QuellList!=&LeftList)
  392.                                                             {
  393.                                                                 TWert=ZielAnzeigeWert;
  394.                                                                 ZielAnzeigeWert=QuellAnzeigeWert;
  395.                                                                 QuellAnzeigeWert=TWert;
  396.  
  397.                                                                 QuellList=&LeftList;
  398.                                                                 ZielList=&RightList;
  399.  
  400.                                                                 QuellGadget=MyGadgets[LViewID];
  401.                                                                 ZielGadget=MyGadgets[RViewID];
  402.  
  403.                                                                 QuellStringGadget=MyGadgets[LStringID];
  404.                                                                 ZielStringGadget=MyGadgets[RStringID];
  405.  
  406.                                                                 QuellToggleGadget=MyGadgets[LToggleID];
  407.                                                                 ZielToggleGadget=MyGadgets[RToggleID];
  408.  
  409.                                                                 QuellAnzeige=QString;
  410.                                                                 ZielAnzeige=ZString;
  411.  
  412.                                                                 SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,
  413.                                                                     WTOGGLEA_Checked,TRUE,TAG_DONE);
  414.  
  415.                                                                 SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,
  416.                                                                     WTOGGLEA_Checked,FALSE,TAG_DONE);
  417.  
  418.                                                                 SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  419.                                                                     WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  420.                                                             }
  421.  
  422.                                                             SelNode=(struct MyListNode *)
  423.                                                                 WZ_GetNode((struct MinList *)QuellList,
  424.                                                                     GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  425.  
  426.                                                             if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  427.                                                             {
  428.                                                                 if (SelNode->Type==FILETYPE)
  429.                                                                 {
  430.                                                                     if (SelNode->Node.Flags&WLNF_Selected)
  431.                                                                         QuellAnzeigeWert+=SelNode->FileSize;
  432.                                                                     else
  433.                                                                         QuellAnzeigeWert-=SelNode->FileSize;
  434.  
  435.                                                                         SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  436.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  437.                                                                 }
  438.                                                             }
  439.                                                             else
  440.                                                                 if (SelNode->Type==DIRTYPE)
  441.                                                                     GoToDir(SelNode->FileName);
  442.  
  443.                                                             break;
  444.  
  445.                                                         case RViewID:                                    /*rechtes MultiView */
  446.                                                             if (QuellList!=&RightList)
  447.                                                             {
  448.                                                                 TWert=ZielAnzeigeWert;
  449.                                                                 ZielAnzeigeWert=QuellAnzeigeWert;
  450.                                                                 QuellAnzeigeWert=TWert;
  451.  
  452.                                                                 ZielList=&LeftList;
  453.                                                                 QuellList=&RightList;
  454.  
  455.                                                                 ZielGadget=MyGadgets[LViewID];
  456.                                                                 QuellGadget=MyGadgets[RViewID];
  457.  
  458.                                                                 ZielStringGadget=MyGadgets[LStringID];
  459.                                                                 QuellStringGadget=MyGadgets[RStringID];
  460.  
  461.                                                                 ZielToggleGadget=MyGadgets[LToggleID];
  462.                                                                 QuellToggleGadget=MyGadgets[RToggleID];
  463.  
  464.                                                                 ZielAnzeige=QString;
  465.                                                                 QuellAnzeige=ZString;
  466.  
  467.                                                                 SetGadgetAttrs(QuellToggleGadget,MyWindow,0L,WTOGGLEA_Checked,TRUE,
  468.                                                                                                                                         TAG_DONE);
  469.                                                                 SetGadgetAttrs(ZielToggleGadget,MyWindow,0L,WTOGGLEA_Checked,FALSE,
  470.                                                                                                                                         TAG_DONE);
  471.                                                                 SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  472.                                                                     WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  473.                                                             }
  474.  
  475.                                                             SelNode=(struct MyListNode *)
  476.                                                                 WZ_GetNode((struct MinList *)QuellList,
  477.                                                                     GetTagData(WLISTVIEWA_Selected,0,msg->IAddress));
  478.  
  479.                                                             if (!GetTagData(WLISTVIEWA_DoubleClick,FALSE,msg->IAddress))
  480.                                                             {
  481.                                                                 if (SelNode->Type==FILETYPE)
  482.                                                                 {
  483.                                                                     if (SelNode->Node.Flags&WLNF_Selected)
  484.                                                                         QuellAnzeigeWert+=SelNode->FileSize;
  485.                                                                     else
  486.                                                                         QuellAnzeigeWert-=SelNode->FileSize;
  487.  
  488.                                                                         SetGadgetAttrs(MyGadgets[AnzeigeID],MyWindow,0L,
  489.                                                                             WARGSA_Arg0,QuellAnzeigeWert,TAG_DONE);
  490.                                                                 }
  491.                                                             }
  492.                                                             else
  493.                                                                 if (SelNode->Type==DIRTYPE)
  494.                                                                     GoToDir(SelNode->FileName);
  495.  
  496.                                                             break;
  497.  
  498.                                                         case ParentID:
  499.                                                             {
  500.                                                                 char NewDir[256],*Dir;
  501.  
  502.                                                                 if (GetAttr(WSTRINGA_String,QuellStringGadget,(ULONG *)&Dir))
  503.                                                                     {
  504.                                                                         strcpy(NewDir,Dir);
  505.  
  506.                                                                         *(PathPart(NewDir))=0;
  507.                                                                         ReadDirectoryList(NewDir,FALSE);
  508.                                                                     }
  509.                                                             }
  510.                                                             break
  511.                                                     }
  512.                                                     break;
  513.  
  514.                                                 case IDCMP_MENUPICK:
  515.  
  516.                                                     switch(msg->Code)
  517.                                                     {
  518.                                                         case FULLMENUNUM(0,0,-1):
  519.                                                             {
  520.                                                                 ULONG Dummy;
  521.  
  522.                                                                 WZ_LockWindow(MyWinHandle);
  523.  
  524.                                                                 WZ_EasyRequestArgs(MySurface,MyWindow,1L,&Dummy);
  525.  
  526.                                                                 WZ_UnlockWindow(MyWinHandle);
  527.                                                             }
  528.                                                             break;
  529.  
  530.                                                         case FULLMENUNUM(0,2,-1):
  531.                                                             MsgClass=IDCMP_CLOSEWINDOW;
  532.                                                             break;
  533.                                                     }
  534.                                                     break;
  535.  
  536.                                                 case IDCMP_MENUHELP :
  537.                                                     SetWindowTitles(MyWindow,WZ_MenuHelp(MyWinHandle,msg->Code),(char *)-1L);
  538.                                                     Delay(50L);
  539.                                                     break;
  540.  
  541.                                                 case IDCMP_GADGETHELP:
  542.                                                     if (msg->IAddress)
  543.                                                     {
  544.                                                             SetWindowTitles(MyWindow,WZ_GadgetHelp(MyWinHandle,msg->IAddress),(char *)-1L);
  545.                                                     }
  546.                                                     break;
  547.                                                 case IDCMP_MOUSEMOVE:
  548.                                                     /* Falls wir unter 2.0 oder 2.1 laufen !!! */
  549.                                                     if (WZ_GadgetHelpMsg(MyWinHandle,&GadgetHelpWinHandle,&GadgetHelpIAddress,msg->MouseX,msg->MouseY,0))
  550.                                                         {
  551.                                                             SetWindowTitles(MyWindow,WZ_GadgetHelp(GadgetHelpWinHandle,GadgetHelpIAddress),(char *)-1L);
  552.                                                         }
  553.                                                     break;
  554.                                                 case IDCMP_INTUITICKS:
  555.  
  556.                                                             FreeChip=AvailMem(MEMF_CHIP)>>10;
  557.                                                             FreeFast=AvailMem(MEMF_FAST)>>10;
  558.  
  559.                                                             DateStamp(&MyDateStamp);
  560.                                                             Amiga2Date(MyDateStamp.ds_Days*24*3600+MyDateStamp.ds_Minute*60+(MyDateStamp.ds_Tick/50),&MyClockData);
  561.  
  562.                                                             SetGadgetAttrs(MyGadgets[StatusID],MyWindow,0L,
  563.                                                                             WARGSA_Arg0,FreeChip,
  564.                                                                             WARGSA_Arg1,FreeFast,
  565.                                                                             WARGSA_Arg2,FreeChip+FreeFast,
  566.                                                                             WARGSA_Arg3,MyClockData.mday,
  567.                                                                             WARGSA_Arg4,MyClockData.month,
  568.                                                                             WARGSA_Arg5,MyClockData.year,
  569.                                                                             WARGSA_Arg6,MyClockData.hour,
  570.                                                                             WARGSA_Arg7,MyClockData.min,
  571.                                                                             WARGSA_Arg8,MyClockData.sec,
  572.                                                                             TAG_DONE);
  573.                                                             break;
  574.  
  575.                                             }
  576.                                             ReplyMsg((struct Message *)msg);
  577.                                         }
  578.                                     } while (MsgClass != IDCMP_CLOSEWINDOW);
  579.  
  580.  
  581.     WZ_CloseWindow(MyWinHandle);
  582.                             }
  583.                         }
  584.  
  585.                         while (QuellList->mlh_Head->mln_Succ)
  586.                         {
  587.                             struct MinNode *t=QuellList->mlh_Head;
  588.  
  589.                             Remove((struct Node *)t);
  590.                             FreeVec(t);
  591.                         };
  592.  
  593.                         while (ZielList->mlh_Head->mln_Succ)
  594.                         {
  595.                             struct MinNode *t=ZielList->mlh_Head;
  596.  
  597.                             Remove((struct Node *)t);
  598.                             FreeVec(t);
  599.                         };
  600.  
  601.                         WZ_FreeWindowHandle(MyWinHandle)
  602.                     }
  603.                     WZ_CloseSurface(MySurface);
  604.                 }
  605.                 UnlockPubScreen(0L,MyScreen);
  606.             }
  607.             CloseLibrary(WizardBase);
  608.         }
  609.         CloseLibrary(UtilityBase);
  610.     }
  611. }